As software applications become increasingly complex, they require a large number of computing resources. For example, modern applications such as Java Virtual Machines (JVMs) running memory intensive mission critical J2EE applications, network management servers, database servers, web servers etc., require additional amounts of heap memory as the size and complexity of the underlying task increases. However, just like any other resource of a computing system, heap memory is finite for a given computer chip and Operating System combination. Therefore, it is imperative that heap memory should be utilized efficiently especially in a heap intensive application.
Typically life of a heap memory block has four important events: memory allocation, first use, last use and memory de-allocation. As described by N. Röjemo and C. Runciman, “Lag, drag, void and use—heap profiling and space-efficient compilation revisited,” Proceedings of ACM SIGPLAN International Conference on Function Programming, pp. 34-41, 1996, and illustrated in FIG. 1 the duration between allocation and first use is called lag, the duration between first use and last use is called use, and the duration between last use and de-allocation is called drag. If the memory is not used at all, the duration between allocation and de-allocation is called void.
The allocation event as illustrated in FIG. 1 is marked by a heap memory allocation call such as malloc( ) method or new operator. The first use and last use events occur when any part of a heap block is used for first and last time respectively. For programming languages with explicit heap memory management such as C/C++, de-allocation event is marked by calling free( ) method or delete operator. For programming languages with implicit memory management, the de-allocation event is marked when the last pointer/reference to that heap memory block is lost thereby making the memory block eligible for garbage collection. It should be noted that conventionally during the drag phase, a memory block is reachable but is not going to be used anymore. Such memory blocks are also known as reachable memory leaks. Evidently, the real utilization of a heap block is only during the use phase. A program that has a lot of heap blocks in lag, drag or void phases, is not utilizing heap efficiently. Software (hereinafter also referred to as program) that has a relatively large amount of heap blocks in lag, drag or void phases, is not efficiently utilizing heap.
IBM® Rational® Purify® described in the following arts R. Hastings and B. Joyce, “Purify: Fast Detection of Memory Leaks and Access Errors,” Proceedings of the Winter Usenix Conference, pp. 125-136, 1992; in U.S. Pat. Nos. 5,193,180, 5,335,334 and 5,535,329 describe detecting memory leaks by instrumenting object code. Using an algorithm similar to mark and sweep garbage collection, it finds all heap memory blocks to which there is no direct or indirect pointer, which is an indication that the heap block has been leaked. A disadvantage with the above cited prior art being that lag and drag cannot be found in the reachable heap memory blocks. Other tools such as Parasoft® Insure++® described in U.S. Pat. Nos. 5,581,696 and 5,842,019 have the same kind of deficiencies of not being sufficiently capable of analyzing lag and drag.
Additionally, several other attempts have been made to optimize heap usage, but have limitations due to scalability problems and/or failure in reducing lag and drag periods in the life of a heap memory block. Moreover, all these methods are designed for object oriented and garbage collected programming languages, where the granularity is either object or fields. Such approaches are not applicable to programming languages like C and C++ where heap memory can be accesses in arbitrarily and randomly by using pointer arithmetic. In C/C++ programming language, the atomic unit is a byte rather than a field or object. Thus, updating timestamp at every byte access has a relatively large runtime cost rendering these techniques unscalable and useless.
Without a way for providing a method and system for automatically providing durations of lag, drag and void phases of all heap memory blocks in a useful manner wherein a user can exploit this information to design program modifications that will reduce or eliminate lag, drag and void phases leading to more efficient heap utilization and reduced maximum and average heap requirements for the program, the promise of this technology may never be fully achieved. The technique described in this invention is more generic and is applicable to programming languages such as C/C++, Java etc., by virtue of the fact that it is applicable to the least-constrained heap memory model of C language, and hence becomes more efficient as a heap memory model become more constrained as in Java. Yet, it is efficient and scalable to be used for optimizing large enterprise scale applications running for long duration of time. Moreover, the technique doesn't require access to or modification in the source code and can be used with the system having third party binary libraries.